
print("excel01")
print("excel02")
print("用队列实现栈")

print("两数之和"
      "数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标")
def liangshuzhihe(nums:list[int],target:int)->list[int]:
    # for i in range(0,len(nums)):
    #     for j in range(i+1,len(nums)):
    #         if nums[i]+nums[j]==target:
    #             return [i,j]

    tem_dict={}
    for k,v in enumerate(nums):
        if target-v in tem_dict:
            return [tem_dict[target-v],v]
        tem_dict[v]=k




print("最长公共前缀")
def zuichanggonggongqianzhui(strs:list[str])->str:
    strs.sort(key=lambda x:len(x))
    prefix=""
    for i in range(0,len(strs[0])):
        if len(set([ss[i] for ss in strs]))>1:
            return prefix
        prefix=prefix+strs[0][i]
    return prefix



print("有效的括号")
def youxiaokuohao01(strs:str)->bool:
    # for i in range(0,len(strs)//2):
    #     strs=strs.replace("()","").replace("{}","").replace("[]","")
    # return len(strs)==0
    stack=[]
    mapping={"}":"{","]":"[",")":"("}
    for s in strs:
        if s in mapping:
            if len(stack)==0:
                return False
            if stack.pop() != mapping[s]:
                return False
        else:
            stack.append(s)
    return len(stack)==0

print("合并两个有序链表"
      "将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def hebingyouxulianbiao(list1:ListNode,list2:ListNode)->ListNode:
    if not list1:
        return list2
    if not list2:
        return list1
    new_head=ListNode()
    current=new_head
    while list1 and list2:
        if list1.val>=list2.val:
            current.next=list2
            list2=list2.next
        else:
            current.next=list1
            list1=list1.next
        current=current.next
    if not list1:
        current.next=list2
    if not list2:
        current.next=list1
    return new_head.next


print("删除有序数组中的重复项")
def shanchuchongfuxiang(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for k,v in counter.items():
        if v>1:
            for i in range(1,v):
                nums.remove(k)
    return len(nums)


    # cp_nums=nums[::]
    # for c in cp_nums:
    #     while nums.count(c)>1:
    #         nums.remove(c)
    # return len(nums)

    # nums2=sorted(list(set(nums)))
    # for i in range(0,len(nums2)):
    #     nums[i]=nums2[i]
    # return len(nums2)


print("移除元素"
      "给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。"
      "然后返回 nums 中与 val 不同的元素的数量")
def yichuyuansu(nums:list[int],val:int)->int:
    count=nums.count(val)
    for i in range(0,count):
        nums.remove(val)
    return len(nums)


print("搜索插入位置"
      "定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置")
def charuweizhi(nums:list[int],target:int)->int:
    if target in nums:
        return nums.index(target)
    else:
        nums.append(target)
        nums.sort()
        return nums.index(target)

print("最后一个单词的长度")
def zuihoudancichangdu(strs:str)->int:
    return len(strs.split()[-1])

print("数组元素加1")
def shuzuyuansujia1(digits:list[int])->list[int]:
    cp_digits=[0]*len(digits)
    cp_digits[-1]=1
    jinwei,i,j=0,len(digits)-1,len(cp_digits)-1
    res=""
    while i>=0:
        temp=digits[i]+cp_digits[j]+jinwei
        res=str(temp%10)+res
        jinwei=temp//10
        i=i-1
        j=j-1
    if jinwei!=0:
        res = str(jinwei) + res
    return [int(r) for r in list(res)]



print("X的算数平方根"
      "由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去")
def suanshupingfanggen(x:int)->int:
    if x<=1:
        return x
    for i in range(0,x):
        if i**2==x:
            return i
        if (i+1)**2>x:
            return i
print("爬楼梯")
def palouti(n:int)->int:
    if n==0 or n==1:
        return 1
    return palouti(n-1)+palouti(n-2)
def palouti2(n:int)->int:
    res=[1,2]
    if n<=2:
        return res[n-1]
    while len(res)<n:
        res.append(res[-1]+res[-2])
    return res[-1]

print("删除排序链表中的重复元素")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def shanchuchongfuyuansu(head:ListNode)->ListNode:
    if not head:
        return None
    current=head
    while current.next:
        if current.val==current.next.val:
            current.next=current.next.next
        else:
            current=current.next
    return head


print("合并两个有序数组"
      "请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。"
      "注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，"
      "其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n")
def merge(nums1:list[int],m:int,nums2:list[int],n:int)->list[int]:
    nums1[m:]=nums2
    nums1.sort()

class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right

print("判断是不是相同的树")
def isSameTree(p:TreeNode,q:TreeNode):
    if not q and not p:
        return True
    if not p or not q or p.val!=q.val:
        return False
    return isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

print("判断是不是对称二叉树")
def isSymmetric(root:TreeNode)->bool:
    def inner(left:TreeNode,right:TreeNode)->bool:
        if not left and not right:
            return True
        if not left or not right or left.val!=right.val:
            return False
        return inner(left.left,right.right) and inner(left.right,right.left)
    if not root:
        return False
    else:
        return inner(root.left,root.right)
print("二叉树的最大深度")
def maxDepth(root:TreeNode)->int:
    if not root:
        return 0
    return max(maxDepth(root.left),maxDepth(root.right))+1

print("判断是不是平衡二叉树"
      "二叉树的每个节点的左右子树的高度差的绝对值不超过 1，则二叉树是平衡二叉树。"
      "根据定义，一棵二叉树是平衡二叉树，当且仅当其所有子树也都是平衡二叉树，因此可以使用递归的方式判断二叉树是不是平衡二叉树，"
      "递归的顺序可以是自顶向下或者自底向上。"
      "1、每一个节点的左子结点和右子节点高度不能大于1"
      "2、每一个节点同时也是平衡二叉树")
def isBalanced(root:TreeNode)->bool:
    def height(node:TreeNode)->int:
        if not node:
            return 0
        return max(height(node.left),height(node.right))+1
    if not root:
        return True
    return abs(height(root.left)-height(root.right))<=1 and isBalanced(root.left) and isBalanced(root.right)

print("树的最小深度")
def minDepth(root:TreeNode)->int:
    if not root:
        return 0
    if not root.left:
        return minDepth(root.right)+1
    if not root.right:
        return minDepth(root.left)+1
    return min(minDepth(root.left),minDepth(root.right))+1


print("路径总和"
      "判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。"
      "如果存在，返回 true ；否则，返回 false 。")
def lujingzonghe(root:TreeNode,targetSum:int)->bool:
    if not root:
        return False
    targetSum=targetSum-root.val
    if not root.left and not root.right:
        return targetSum==0
    return lujingzonghe(root.left,targetSum) or lujingzonghe(root.right,targetSum)

print("给定一个非负整数n，返回杨辉三角的前n行")
def yanghuisanjiao001(numRows:int)->list[list[int]]:
    source_list = [[1]*i for i in range(1,numRows+1)]
    if numRows<=2:
        return source_list
    for i in range(2,numRows):
        for j in range(1,len(source_list[i])-1):
            source_list[i][j]=source_list[i-1][j-1]+source_list[i-1][j]
    return source_list

print("给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行")
def yanghuisanjiao002(numRows:int)->list[int]:
    source_list=[[1]*(r+1) for r in range(0,numRows+1)]
    for i in range(2,numRows+1):
        for j in range(1,len(source_list[i])-1):
            source_list[i][j]=source_list[i-1][j-1]+source_list[i-1][j]
    return source_list[numRows]


print("买卖股票的最佳时机")
def maimaigupiao(prices:list[int])->int:
    lirun=0
    min_price=prices[0]
    for p in prices[1:]:
        min_price=min(p,min_price)
        lirun=max(lirun,p-min_price)
    return lirun


print("验证回文串"
      "如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串"
      "字母和数字都属于字母数字字符"
      "s = 'A man, a plan, a canal: Panama'")
def yanzhenghuiwenchuan(s:str)->bool:
    res=""
    for ss in s:
        if ss.isdigit():
            res=res+ss
        if ss.isalpha():
            res=res+ss.lower()
    return res==res[::-1]


print("只出现一次的元素"
      "给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素")
def zhichuxainyiciyuansu(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for k,v in counter.items():
        if v==1:
            return k


print("判断是不是环形链表")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=0
        self.next=next

def huanxinglianbiao(head:ListNode)->bool:
    if not head:
        return False
    fast=head
    slow=head
    while fast and fast.next:
        if not fast.next.next:
            return False
        fast=fast.next.next
        slow=slow.next
        if fast==slow:
            return True
    return False
print("二叉树的前序遍历、中序遍历、后序遍历")
class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right
def qianxubianli(root:TreeNode)->list[int]:
    res=[]
    def innnerdigui(node:TreeNode):
        if not node:
            return
        res.append(node.val)
        innnerdigui(node.left)
        innnerdigui(node.right)
    innnerdigui(root)
    return res
def zhongxubianli(root:TreeNode)->list[int]:
    res=[]
    def innerdigui(node:TreeNode):
        if not node:
            return
        innerdigui(node.left)
        res.append(node.val)
        innerdigui(node.right)
    innerdigui(root)
    return res
def houxubianli(root:TreeNode)->list[int]:
    res=[]
    def innerdigui(node:TreeNode):
        if not node:
            return
        innerdigui(node.left)
        innerdigui(node.right)
        res.append(node.val)
    innerdigui(root)
    return res

print("返回相交链表的相交节点")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def xiangjiaojiedian(headA:ListNode,headB:ListNode)->ListNode:
    if not headA or not headB:
        return None
    current=headA
    tem_list=[]
    while current:
        tem_list.append(current)
        current=current.next
    current=headB
    while current:
        if current in tem_list:
            return current
        current=current.next
    return None


print("判断是不是多数元素"
      "给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素")
def duoshuyuansu(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    tem=len(nums)/2
    for k,v in counter.items():
        if v>tem:
            return k

print("判断是不是快乐数"
      "正整数各个位上的数的平方反复相加，看最终结果是否能等于1")
def kuaileshu(n:int)->bool:
    tem_list=[]
    while True:
        res=0
        for i in str(n):
            res=int(i)**2+res
        if res==1:
            return True
        if res in tem_list:
            return False
        tem_list.append(res)
        n=res



print("移除链表元素"
      "给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next

def yichulianbiaoyuansu(head:ListNode,val:int)->ListNode:
    if not head:
        return None
    new_head=ListNode()
    new_head.next=head
    current=new_head
    while current.next:
        if current.next.val==val:
            current.next=current.next.next
        else:
            current=current.next
    return new_head.next




print("给定两个字符串，判定他们是否是同构字符串"
      "s = 'egg', t = 'add'")
def tonggouzifuchuan(s:str,t:str)->bool:
    list_s=list(s)
    list_t=list(t)
    map_s={}
    map_t={}
    for k,v in zip(list_s,list_t):
        if k in map_s:
            if map_s[k] !=v:
                return False
        else:
            map_s[k]=v
        if v in map_t:
            if map_t[v] !=k:
                return False
        else:
            map_t[v]=k
    return True

print("反转链表")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def fanzhuanlianbiao(head:ListNode)->ListNode:
    if not head:
        return None
    pre=None
    current=head
    while current:
        temp=current.next
        current.next=pre
        pre=current
        current=temp
    return pre


print("存在重复元素 - 001"
      "简单的判断数组中是否有重复元素")
def chognfuyuansu01(nums:list[int])->bool:
    return len(set(nums)) == len(nums)

print("存在重复元素 - 002"
      "给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，"
      "满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false ")
def chongfuyuansu02(nums:list[int],k:int)->bool:
    num_index={}
    for index,num in enumerate(nums):
        if num in num_index and abs(num_index[num]-index)<=k:
            return True
        num_index[num]=index
    return False



print("完全二叉树的节点个数")
class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right
def countNodes(root:TreeNode) ->int:
    if not root:
        return 0
    return countNodes(root.left)+countNodes(root.right)+1

print("反转二叉树")
class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right
def fanzhuanerchashu(root:TreeNode)->TreeNode:
    if not root:
        return
    left=fanzhuanerchashu(root.left)
    right=fanzhuanerchashu(root.right)
    root.left=right
    root.right=left
    return root

print("2的幂")
def mi_2(n:int)->bool:
    if n<=0:
        return False
    if n==1:
        return True
    res=1
    for i in range(0,n):
        res=res*2
        if res==n:
            return True
        if res>n:
            return False

print("回文链表")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def huiwenlianbiao(head:ListNode)->bool:
    if not head:
        return False
    current=head
    res=[]
    while current:
        res.append(current.val)
        current=current.next
    return res==res[::-1]

print("有效的字母异位词"
      "字母异位词 是通过重新排列不同单词或短语的字母而形成的单词或短语，通常只使用所有原始字母一次"
      "判断 t 是否是 s 的字母异位词  "
      "其实就是判断两个字符串长度是否相等  如果相等的话 两个字符串中每个字符出现的次数相等")
def yiweici(s:str,t:str)->bool:
    import collections
    dicts=collections.Counter(s)
    dictt=collections.Counter(t)
    if len(dicts) != len(dictt):
        return False
    else:
        for k,v in dicts.items():
            if dictt[k] != v:
                return False
    return True






print("各位相加"
      "给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果")
def geweixiangjia(num:int)->int:
    if num<10:
        return num
    while num>=10:
        list_n = [int(l) for l in list(str(num))]
        num=sum(list_n)
        if num<10:
            return num



print("判断是不是丑数")
def choushu(n:int)->bool:
    if n<=0:
        return False
    factors=[2,3,5]
    for f in factors:
        while n%f==0:
            n=n//f

    return True if n==1 else False


print("丢失的数字"
      "给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数")
def diushideshuzi(nums:list[int])->int:
    import collections
    dict_num=collections.Counter(nums)
    for i in range(0,len(nums)+1):
        if dict_num[i]==0:
            return i


print("第一个错误版本")
def isBadVersion(i:int)->bool:
    pass
def firstbadversion(n:int)->int:
    left,right=1,n
    while left<=right:
        mid=(left+right)//2
        if isBadVersion(mid):
            right=mid-1
        else:
            left=mid+1
    return left




print("移动0"
      "编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序")
def yidong0(nums:list[int])->list[int]:
    count = nums.count(0)
    for i in range(0,count):
        # remove方法是根据值删除列表中的第一个元素
        nums.remove(0)
        nums.append(0)


print("单词规律"
      "给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律"
      "pattern = 'abba', s = 'dog cat cat dog'"
      )
def danciguilv(pattern:str,s:str)->bool:
    list_p=list(pattern)
    list_s=s.split()
    if len(list_p) != len(list_s):
        return False
    map1={}
    map2={}
    for p,s in zip(list_p,list_s):
        if p in map1:
            if map1[p] != s:
                return False
        else:
            map1[p]=s
        if s in map2:
            if map2[s] != p:
                return False
        else:
            map2[s]=p
    return True





print("nim游戏")
def nim(n:int)->bool:
    return not n%4 == 0


print("3的幂")
def mi_3(n:int)->bool:
    if n<=0:
        return False
    if n==1:
        return True
    res=1
    while True:
        res=res*3
        if res==n:
            return True
        if res>n:
            return False


print("4的幂")
def mi_4(n:int)->bool:
    if n<=0:
        return False
    if n==1:
        return True
    # if 1<n and n<4:
    #     return False
    res = 1
    for i in range(1,n):
        res = res*4
        if res>n:
            return False
        if res==n:
            return True




print("不额外分配空间翻转字符串")
def fanzhuanstr(s:list[str])->list[str]:
    for i in range(0,len(s)//2):
        # tem=s[i]
        # s[i]=s[len(s)-1-i]
        # s[len(s)-1-i]=tem
        s[i],s[len(s)-i-1]=s[len(s)-i-1],s[i]



print("反转字符串中的元音字母"
      "只有两个索引位置的值都是原因字母时才翻转")
def fanzhuanyuanyin(s:str)->str:
    l,r=0,len(s)-1
    chars = list(s)
    vowels = set("aeiouAEIOU")
    while l<r:
        if chars[l] not in vowels:
            l=l+1
        elif chars[r] not in vowels:
            r=r-1
        else:
            chars[l],chars[r]=chars[r],chars[l]
            l=l+1
            r=r-1
    return "".join(chars)
print(fanzhuanyuanyin("hhto"))



print("两个数组的交集"
      "每个元素只出现一次")
def intersect2(nums1:list[int],nums2:list[int])->list[int]:
    # return list(set(nums1).intersection(set(nums2)))
    import collections
    return list((collections.Counter(nums1))&(collections.Counter(nums2)))
nums1=[1,2,2,1]
nums2=[2,2]
print(intersect2(nums1,nums2))


print("两个数组的交集"
      "给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。"
      "返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数"
      "一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。")
def intersect(nums1:list,nums2:list)->list[int]:
    import collections
    return list(((collections.Counter(nums1))&(collections.Counter(nums2))).elements())
# ((collections.Counter(nums1))&(collections.Counter(nums2)))是返回一个新的counter对象，
# 并且每个元素出现的次数被设置为两个原始计数器中该元素出现次数的最小值，在调用counter对象的elements方法
# 返回一个迭代器，并且迭代器中可能会有重复元素

 # Counter 不会存储负数或零计数
from collections import Counter
nums1 = [1, 2, 2, 3, 4, 3, 4, 3]
nums2 = [1, 2, 5, 3]
result = list(((Counter(nums1)) - (Counter(nums2))))
result2 = list(((Counter(nums1)) - (Counter(nums2))).elements())
print(result)  #所以输出是：[(2, 1), (3, 2), (4, 2)]
print(result2)

print("有效的完全平方数"
      "给你一个正整数 num")
def youxiaowanquanpingfangshu(num:int)->bool:
    if num<0:
        return False
    if num==0 or num==1:
        return True
    for i in range(0,num):
        if i**2==num:
            return True
        if (i+1)**2>num:
            return False

print("二分法猜数字大小"
      "从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字")
def guess(num:int)->bool:
    pass
def guessnumber(n:int)->int:
    left=1
    right=n
    while left<=right:
        mid=(left+right)//2
        if guess(mid)==0:
            return mid
        elif guess(mid)<0:
            right=mid-1
        else:
            left = left+1
    return -1

print("给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成"
      "magazine 中的每个字符只能在 ransomNote 中使用一次")
def canconstruct(ransomNote:str,magazine:str)->bool:
    import collections
    cm=collections.Counter(magazine)
    for r in ransomNote:
        cm[r]=cm[r]-1
        if cm[r]<0:
            return False
    return True



print("给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1")
def findfirstchar(s:str)->int:
    import collections
    dicts=collections.Counter(s)
    for k,v in enumerate(s):
        if dicts[v]==1:
            return k
    return -1


print("找不同找出随机添加的字符串 "
      "字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。"
      "请找出在 t 中被添加的字母。")
def finddiff(s:str,t:str)->str:
    import collections
    return list(collections.Counter(t)-collections.Counter(s))[0]




print("s" in "ss")
print("判断子序列"
      "字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。"
      "（例如，'ace'是'abcde'的一个子序列，而'aec'不是）"
      "判断 s 是否为 t 的子序列")
def zixulie(s:str,t:str)->bool:
    i = 0
    for c in t:
        if s[i]==c:
            i=i+1
            if i==len(s):
                return True
    return False





print("给定二叉树的根节点 root ，返回所有左叶子之和")
class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right
def zuoyezihe(root:TreeNode)->int:
    res = []
    def inner(node:TreeNode):
        if not node:
            return
        if node.left is not None and node.left.left is None and node.left.right is None:
            res.append(node.left.val)
        inner(node.left)
        inner(node.right)
    inner(root)
    return sum(res)


print("返回最长回文串")
def zuichanghuiwenchuan(s:str)->int:
    import collections
    dicts = dict(collections.Counter(s))
    res=0
    tem=0
    for k,v in dicts.items():
        if v%2==0:
            res = res+v
        if v%2==1:
            res = res+(v//2)*2
            tem=1
    return res+tem



print("返回数组中第三大的数")
def max_3(nums:list[int]) ->int:
    nums=sorted(list(set(nums)))
    if len(nums)<3:
        return nums[-1]
    else:
        return nums[-3]



print("字符串相加")
def strxiangjia(num1:str,num2:str)->str:
    res=""
    jinwei,i,j=0,len(num1)-1,len(num2)-1
    while i>=0 or j>=0:
        n1=int(num1[i]) if i>=0 else 0
        n2=int(num2[j]) if j>=0 else 0
        tem=n1+n2+jinwei
        res=str(tem%10)+res
        jinwei=tem//10
        i=i-1
        j=j-1
    if jinwei>0:
        return str(jinwei)+res
    else:
        return res


print("返回字符串中的单词数"
      "这里的单词指的是连续的不是空格的字符")
def dancishu(s:str)->int:
    return len(s.split())

print("排列硬币-返回完整阶梯行")
def wanzhengjieti(n:int)->int:
    res=0
    for i in range(1,n+1):
        res = i+res
        if res ==n:
            return i
        if res >n:
            return i-1


print("找到所有的从数组中消失的数字"
      "给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内"
      "但没有出现在 nums 中的数字，并以数组的形式返回结果")
def xiaoshishuzi(nums:list[int])->list[int]:
    import collections
    counter = collections.Counter(nums)
    res = []
    for i in range(1,len(nums)+1):
        if counter[i] ==0:
            res.append(i)
    return res


print("分发饼干")
def fenfabinggan(g:list[int],s:list[int])->int:
    len_g=len(g)
    len_s=len(s)
    g.sort()
    s.sort()
    res,child,cookie=0,0,0
    while child<len_g and cookie<len_s:
        if g[child]<=s[cookie]:
            res = res+1
            child=child+1
            cookie=cookie+1
        else:
            cookie=cookie+1
    return res


print("重复的子字符串"
      "给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成")
def chongfuzizifuchuan(s:str)->bool:
    for i in range(1,len(s)):
        flag=len(s)%len(s[0:i])
        count=len(s)//len(s[0:i])
        if flag==0:
            tem=s[::]
            for j in range(0,count):
                tem = tem.replace(s[0:i],"")
            if len(tem) ==0:
                return True
    return False





